/**
 * turn.js 4th release
 * turnjs.com
 * turnjs.com/license.txt
 *
 * Copyright (C) 2012 Emmanuel Garcia
 * All rights reserved
 **/

 (function($) {

    'use strict';
    
    var has3d,
      
      hasRot,
    
      vendor = '',
      
      version = '4.1.0',
    
      PI = Math.PI,
    
      A90 = PI/2,
    
      isTouch = 'ontouchstart' in window,
    
      mouseEvents = (isTouch) ?
        {
          down: 'touchstart',
          move: 'touchmove',
          up: 'touchend',
          over: 'touchstart',
          out: 'touchend'
        }
        :
        {
          down: 'mousedown',
          move: 'mousemove',
          up: 'mouseup',
          over: 'mouseover',
          out: 'mouseout'
        },
    
      // Contansts used for each corner
      //   | tl * tr |
      // l | *     * | r
      //   | bl * br |
    
      corners = {
        backward: ['bl', 'tl'],
        forward: ['br', 'tr'],
        all: ['tl', 'bl', 'tr', 'br', 'l', 'r']
      },
    
      // Display values
    
      displays = ['single', 'double'],
    
      // Direction values
    
      directions = ['ltr', 'rtl'],
    
      // Default options
    
      turnOptions = {
    
        // Enables hardware acceleration
    
        acceleration: true,
    
        // Display
    
        display: 'double',
    
        // Duration of transition in milliseconds
    
        duration: 600,
    
        // First page
    
        page: 1,
        
        // Enables gradients
    
        gradients: true,
    
        // Corners used when turning the page
    
        turnCorners: 'bl,br',
    
        // Events
    
        when: null
      },
    
      flipOptions = {
    
        // Size of the active zone of each corner
    
        cornerSize: 100
    
      },
    
      // Number of pages in the DOM, minimum value: 6
    
      pagesInDOM = 6,
      
    
    turnMethods = {
    
      // Singleton constructor
      // $('#selector').turn([options]);
    
      init: function(options) {
    
        // Define constants
        
        has3d = 'WebKitCSSMatrix' in window || 'MozPerspective' in document.body.style;
        hasRot = rotationAvailable();
        vendor = getPrefix();
    
        var i, that = this, pageNum = 0, data = this.data(), ch = this.children();
    
        // Set initial configuration
    
        options = $.extend({
          width: this.width(),
          height: this.height(),
          direction: this.attr('dir') || this.css('direction') || 'ltr'
        }, turnOptions, options);
    
        data.opts = options;
        data.pageObjs = {};
        data.pages = {};
        data.pageWrap = {};
        data.pageZoom = {};
        data.pagePlace = {};
        data.pageMv = [];
        data.zoom = 1;
        data.totalPages = options.pages || 0;
        data.eventHandlers = {
          touchStart: $.proxy(turnMethods._touchStart, this),
          touchMove: $.proxy(turnMethods._touchMove, this),
          touchEnd: $.proxy(turnMethods._touchEnd, this),
          start: $.proxy(turnMethods._eventStart, this)
        };
    
    
    
        // Add event listeners
    
        if (options.when)
          for (i in options.when)
            if (has(i, options.when))
              this.bind(i, options.when[i]);
    
        // Set the css
    
        this.css({position: 'relative', width: options.width, height: options.height});
    
        // Set the initial display
    
        this.turn('display', options.display);
    
        // Set the direction
    
        if (options.direction!=='')
          this.turn('direction', options.direction);
        
        // Prevent blue screen problems of switching to hardware acceleration mode
        // By forcing hardware acceleration for ever
    
        if (has3d && !isTouch && options.acceleration)
          this.transform(translate(0, 0, true));
    
        // Add pages from the DOM
    
        for (i = 0; i<ch.length; i++) {
          if ($(ch[i]).attr('ignore')!='1') {
            this.turn('addPage', ch[i], ++pageNum);
          }
        }
    
        // Event listeners
    
        $(this).bind(mouseEvents.down, data.eventHandlers.touchStart).
          bind('end', turnMethods._eventEnd).
          bind('pressed', turnMethods._eventPressed).
          bind('released', turnMethods._eventReleased).
          bind('flip', turnMethods._flip);
    
        $(this).parent().bind('start', data.eventHandlers.start);
    
        $(document).bind(mouseEvents.move, data.eventHandlers.touchMove).
          bind(mouseEvents.up, data.eventHandlers.touchEnd);
    
        // Set the initial page
    
        this.turn('page', options.page);
    
        // This flipbook is ready
    
        data.done = true;
    
        return this;
      },
    
      // Adds a page from external data
    
      addPage: function(element, page) {
    
        var currentPage,
          className,
          incPages = false,
          data = this.data(),
          lastPage = data.totalPages+1;
    
        if (data.destroying)
          return false;
    
        // Read the page number from the className of `element` - format: p[0-9]+
    
        if ((currentPage = /\bp([0-9]+)\b/.exec($(element).attr('class'))))
          page = parseInt(currentPage[1], 10);
    
        if (page) {
          
          if (page==lastPage)
            incPages = true;
          else if (page>lastPage)
            throw turnError('Page "'+page+'" cannot be inserted');
    
        } else {
          
          page = lastPage;
          incPages = true;
    
        }
    
        if (page>=1 && page<=lastPage) {
    
          if (data.display=='double')
            className = (page%2) ? ' odd' : ' even';
          else
            className = '';
    
          // Stop animations
          if (data.done)
            this.turn('stop');
    
          // Move pages if it's necessary
          if (page in data.pageObjs)
            turnMethods._movePages.call(this, page, 1);
    
          // Increase the number of pages
          if (incPages)
            data.totalPages = lastPage;
    
          // Add element
          data.pageObjs[page] = $(element).
            css({'float': 'left'}).
            addClass('page p' + page + className);
    
          if (!hasHardPage() &&  data.pageObjs[page].hasClass('hard')) {
            data.pageObjs[page].removeClass('hard');
          }
    
          // Add page
          turnMethods._addPage.call(this, page);
    
          // Remove pages out of range
          turnMethods._removeFromDOM.call(this);
        }
    
        return this;
      },
    
      // Adds a page
    
      _addPage: function(page) {
        
        var data = this.data(),
          element = data.pageObjs[page];
    
        if (element)
          if (turnMethods._necessPage.call(this, page)) {
    
            if (!data.pageWrap[page]) {
    
              // Wrapper
              data.pageWrap[page] = $('<div/>',
                {'class': 'page-wrapper',
                  page: page,
                  css: {position: 'absolute',
                  overflow: 'hidden'}});
    
              // Append to this flipbook
              this.append(data.pageWrap[page]);
    
              if (!data.pagePlace[page]) {
                
                data.pagePlace[page] = page;
                // Move `pageObjs[page]` to wrapper
                data.pageObjs[page].appendTo(data.pageWrap[page]);
              
             }
    
              // Set the size of the page
              var prop = turnMethods._pageSize.call(this, page, true);
              element.css({width: prop.width, height: prop.height});
              data.pageWrap[page].css(prop);
    
            }
    
            if (data.pagePlace[page] == page) {
    
             // If the page isn't in another place, create the flip effect
              turnMethods._makeFlip.call(this, page);
    
          }
            
          } else {
    
            // Place
            data.pagePlace[page] = 0;
    
            // Remove element from the DOM
            if (data.pageObjs[page])
              data.pageObjs[page].remove();
    
          }
    
      },
    
      // Checks if a page is in memory
      
      hasPage: function(page) {
    
        return has(page, this.data().pageObjs);
      
      },
    
      // Centers the flipbook
    
      center: function(page) {
        
        var data = this.data(),
          size = $(this).turn('size'),
          left = 0;
    
        if (!data.noCenter) {
          if (data.display=='double') {
            var view = this.turn('view', page || data.tpage || data.page);
    
            if (data.direction=='ltr') {
              if (!view[0])
                left -= size.width/4;
              else if (!view[1])
                left += size.width/4;
            } else {
              if (!view[0])
                left += size.width/4;
              else if (!view[1])
                left -= size.width/4;
            }
          
          }
    
          //$(this).css({marginLeft: left});
        }
    
        return this;
    
      },
    
      // Destroys the flipbook
    
      destroy: function () {
    
        var page,
          flipbook = this,
          data = this.data(),
          events = [
            'end', 'first', 'flip', 'last', 'pressed',
            'released', 'start', 'turning', 'turned',
            'zooming', 'missing'];
    
        if (trigger('destroying', this)=='prevented')
          return;
    
        data.destroying = true;
    
        $.each(events, function(index, eventName) {
          flipbook.unbind(eventName);
        });
    
        this.parent().unbind('start', data.eventHandlers.start);
    
        $(document).unbind(mouseEvents.move, data.eventHandlers.touchMove).
          unbind(mouseEvents.up, data.eventHandlers.touchEnd);
        
        while (data.totalPages!==0) {
          this.turn('removePage', data.totalPages);
        }
    
        if (data.fparent)
          data.fparent.remove();
    
        if (data.shadow)
          data.shadow.remove();
    
        this.removeData();
        data = null;
    
        return this;
    
      },
    
      // Checks if this element is a flipbook
    
      is: function() {
    
        return typeof(this.data().pages)=='object';
    
      },
    
      // Sets and gets the zoom value
    
      zoom: function(newZoom) {
        
        var data = this.data();
    
        if (typeof(newZoom)=='number') {
    
          if (newZoom<0.001 || newZoom>100)
            throw turnError(newZoom+ ' is not a value for zoom');
          
          if (trigger('zooming', this, [newZoom, data.zoom])=='prevented')
            return this;
          
          var size = this.turn('size'),
            currentView = this.turn('view'),
            iz = 1/data.zoom,
            newWidth = Math.round(size.width * iz * newZoom),
            newHeight = Math.round(size.height * iz * newZoom);
        
          data.zoom = newZoom;
    
          $(this).turn('stop').
            turn('size', newWidth, newHeight);
            /*.
            css({marginTop: size.height * iz / 2 - newHeight / 2});*/
    
          if (data.opts.autoCenter)
            this.turn('center');
          /*else
            $(this).css({marginLeft: size.width * iz / 2 - newWidth / 2});*/
    
          turnMethods._updateShadow.call(this);
    
          for (var i = 0; i<currentView.length; i++) {
            if (currentView[i] && data.pageZoom[currentView[i]]!=data.zoom) {
      
              this.trigger('zoomed',[
                currentView[i],
                currentView,
                data.pageZoom[currentView[i]],
                data.zoom]);
    
              data.pageZoom[currentView[i]] = data.zoom;
          }
        }
    
          return this;
    
        } else
          return data.zoom;
    
      },
    
      // Gets the size of a page
    
      _pageSize: function(page, position) {
    
        var data = this.data(),
          prop = {};
    
        if (data.display=='single') {
    
          prop.width = this.width();
          prop.height = this.height();
    
          if (position) {
            prop.top = 0;
            prop.left = 0;
            prop.right = 'auto';
          }
    
        } else {
    
          var pageWidth = this.width()/2,
            pageHeight = this.height();
    
          if (data.pageObjs[page].hasClass('own-size')) {
            prop.width = data.pageObjs[page].width();
            prop.height = data.pageObjs[page].height();
          } else {
            prop.width = pageWidth;
            prop.height = pageHeight;
          }
          
          if (position) {
            var odd = page%2;
            prop.top = (pageHeight-prop.height)/2;
    
            if (data.direction=='ltr') {
              
              prop[(odd) ? 'right' : 'left'] = pageWidth-prop.width;
              prop[(odd) ? 'left' : 'right'] = 'auto';
    
            } else {
              
              prop[(odd) ? 'left' : 'right'] = pageWidth-prop.width;
              prop[(odd) ? 'right' : 'left'] = 'auto';
    
            }
          
          }
        }
    
        return prop;
    
      },
    
      // Prepares the flip effect for a page
    
      _makeFlip: function(page) {
    
        var data = this.data();
    
        if (!data.pages[page] && data.pagePlace[page]==page) {
    
          var single = data.display=='single',
            odd = page%2;
    
          data.pages[page] = data.pageObjs[page].
            css(turnMethods._pageSize.call(this, page)).
            flip({
              page: page,
              next: (odd || single) ? page+1 : page-1,
              turn: this
            }).
            flip('disable', data.disabled);
    
            // Issue about z-index
            turnMethods._setPageLoc.call(this, page);
    
            data.pageZoom[page] = data.zoom;
    
        }
    
        return data.pages[page];
      },
    
      // Makes pages within a range
    
      _makeRange: function() {
    
        var page, range,
          data = this.data();
    
        if (data.totalPages<1)
          return;
    
        range = this.turn('range');
    
        for (page = range[0]; page<=range[1]; page++)
          turnMethods._addPage.call(this, page);
    
      },
    
      // Returns a range of pages that should be in the DOM
      // Example:
      // - page in the current view, return true
      // * page is in the range, return true
      // Otherwise, return false
      //
      // 1 2-3 4-5 6-7 8-9 10-11 12-13
      //   **  **  --   **  **
    
      range: function(page) {
    
        var remainingPages, left, right, view,
          data = this.data();
    
          page = page || data.tpage || data.page || 1;
          view = turnMethods._view.call(this, page);
    
          if (page<1 || page>data.totalPages)
            throw turnError('"'+page+'" is not a valid page');
    
        
          view[1] = view[1] || view[0];
          
          if (view[0]>=1 && view[1]<=data.totalPages) {
    
            remainingPages = Math.floor((pagesInDOM-2)/2);
    
            if (data.totalPages-view[1] > view[0]) {
              left = Math.min(view[0]-1, remainingPages);
              right = 2*remainingPages-left;
            } else {
              right = Math.min(data.totalPages-view[1], remainingPages);
              left = 2*remainingPages-right;
            }
    
          } else {
            left = pagesInDOM-1;
            right = pagesInDOM-1;
          }
    
          return [Math.max(1, view[0]-left),
              Math.min(data.totalPages, view[1]+right)];
    
      },
    
      // Detects if a page is within the range of `pagesInDOM` from the current view
    
      _necessPage: function(page) {
        
        if (page===0)
          return true;
    
        var range = this.turn('range');
    
        return this.data().pageObjs[page].hasClass('fixed') ||
          (page>=range[0] && page<=range[1]);
        
      },
    
      // Releases memory by removing pages from the DOM
    
      _removeFromDOM: function() {
    
        var page, data = this.data();
    
        for (page in data.pageWrap)
          if (has(page, data.pageWrap) &&
            !turnMethods._necessPage.call(this, page))
          turnMethods._removePageFromDOM.call(this, page);
        
      },
    
      // Removes a page from DOM and its internal references
    
      _removePageFromDOM: function(page) {
    
        var data = this.data();
    
        if (data.pages[page]) {
          var dd = data.pages[page].data();
    
          flipMethods._moveFoldingPage.call(data.pages[page], false);
    
          if (dd.f && dd.f.fwrapper)
            dd.f.fwrapper.remove();
    
          data.pages[page].removeData();
          data.pages[page].remove();
          delete data.pages[page];
        }
    
        if (data.pageObjs[page])
          data.pageObjs[page].remove();
    
        if (data.pageWrap[page]) {
          data.pageWrap[page].remove();
          delete data.pageWrap[page];
        }
    
        turnMethods._removeMv.call(this, page);
    
        delete data.pagePlace[page];
        delete data.pageZoom[page];
    
      },
    
      // Removes a page
    
      removePage: function(page) {
    
        var data = this.data();
    
        // Delete all the pages
        if (page=='*') {
          
          while (data.totalPages!==0) {
            this.turn('removePage', data.totalPages);
          }
    
        } else {
    
          if (page<1 || page>data.totalPages)
            throw turnError('The page '+ page + ' doesn\'t exist');
            
          if (data.pageObjs[page]) {
    
            // Stop animations
            this.turn('stop');
    
            // Remove `page`
            turnMethods._removePageFromDOM.call(this, page);
    
            delete data.pageObjs[page];
    
          }
    
          // Move the pages
          turnMethods._movePages.call(this, page, -1);
    
          // Resize the size of this flipbook
          data.totalPages = data.totalPages-1;
    
          // Check the current view
    
          if (data.page>data.totalPages) {
    
           data.page = null;
           turnMethods._fitPage.call(this, data.totalPages);
    
          } else {
    
            turnMethods._makeRange.call(this);
            this.turn('update');
    
          }
        }
    
        return this;
      
      },
    
      // Moves pages
    
      _movePages: function(from, change) {
    
        var page,
          that = this,
          data = this.data(),
          single = data.display=='single',
          move = function(page) {
    
            var next = page + change,
              odd = next%2,
              className = (odd) ? ' odd ' : ' even ';
    
            if (data.pageObjs[page])
              data.pageObjs[next] = data.pageObjs[page].
                removeClass('p' + page + ' odd even').
                addClass('p' + next + className);
    
            if (data.pagePlace[page] && data.pageWrap[page]) {
    
              data.pagePlace[next] = next;
            
              if (data.pageObjs[next].hasClass('fixed'))
                data.pageWrap[next] = data.pageWrap[page].
                  attr('page', next);
              else
                data.pageWrap[next] = data.pageWrap[page].
                  css(turnMethods._pageSize.call(that, next, true)).
                  attr('page', next);
          
                if (data.pages[page])
                  data.pages[next] = data.pages[page].
                    flip('options', {
                      page: next,
                      next: (single || odd) ? next+1 : next-1
                    });
    
                if (change) {
                  delete data.pages[page];
                  delete data.pagePlace[page];
                  delete data.pageZoom[page];
                  delete data.pageObjs[page];
                  delete data.pageWrap[page];
                }
    
            }
    
        };
    
        if (change>0)
          for (page=data.totalPages; page>=from; page--)
            move(page);
        else
          for (page=from; page<=data.totalPages; page++)
            move(page);
    
      },
    
      // Sets or Gets the display mode
    
      display: function(display) {
    
        var data = this.data(),
          currentDisplay = data.display;
    
        if (display===undefined) {
          
          return currentDisplay;
    
        } else {
    
          if ($.inArray(display, displays)==-1)
            throw turnError('"'+display + '" is not a value for display');
          
          switch(display) {
            case 'single':
    
              // Create a temporal page to use as folded page
    
              if (!data.pageObjs[0]) {
                this.turn('stop').
                  css({'overflow': 'hidden'});
    
                data.pageObjs[0] = $('<div />',
                    {'class': 'page p-temporal'}).
                  css({width: this.width(), height: this.height()}).
                  appendTo(this);
              }
    
              this.addClass('shadow');
    
            break;
            case 'double':
    
              // Remove the temporal page
    
              if (data.pageObjs[0]) {
                this.turn('stop').css({'overflow': ''});
                data.pageObjs[0].remove();
                delete data.pageObjs[0];
              }
    
              this.removeClass('shadow');
    
            break;
          }
          
    
          data.display = display;
    
          if (currentDisplay) {
            var size = this.turn('size');
            turnMethods._movePages.call(this, 1, 0);
            this.turn('size', size.width, size.height).
              turn('update');
          }
    
          return this;
    
        }
      
      },
      
      // Gets and sets the direction of the flipbook
    
      direction: function(dir) {
    
        var data = this.data();
    
        if (dir===undefined) {
    
          return data.direction;
    
        } else {
    
          dir = dir.toLowerCase();
    
          if ($.inArray(dir, directions)==-1)
            throw turnError('"' + dir + '" is not a value for direction');
    
          if (dir=='rtl') {
            $(this).attr('dir', 'ltr').
              css({direction: 'ltr'});
          }
    
          data.direction = dir;
    
          if (data.done)
            this.turn('size', $(this).width(), $(this).height());
    
          return this;
        }
    
      },
    
      // Detects animation
    
      animating: function() {
    
        return this.data().pageMv.length>0;
    
      },
    
      // Gets the current activated corner
    
      corner: function() {
        
        var corner,
          page,
          data = this.data();
    
        for (page in data.pages) {
          if (has(page, data.pages))
            if ((corner = data.pages[page].flip('corner'))) {
              return corner;
            }
        }
    
        return false;
      },
    
      // Gets the data stored in the flipbook
    
      data: function() {
        
        return this.data();
    
      },
    
      // Disables and enables the effect
    
      disable: function(disable) {
    
        var page,
          data = this.data(),
          view = this.turn('view');
    
        data.disabled = disable===undefined || disable===true;
    
        for (page in data.pages) {
          if (has(page, data.pages))
            data.pages[page].flip('disable',
              (data.disabled) ? true : $.inArray(parseInt(page, 10), view)==-1);
        }
    
        return this;
    
      },
    
      // Disables and enables the effect
    
      disabled: function(disable) {
    
        if (disable===undefined) {
          return this.data().disabled===true;
        } else {
          return this.turn('disable', disable);
        }
    
      },
    
      // Gets and sets the size
    
      size: function(width, height) {
    
        if (width===undefined || height===undefined) {
          
          return {width: this.width(), height: this.height()};
    
        } else {
    
          this.turn('stop');
    
          var page, prop,
            data = this.data(),
            pageWidth = (data.display=='double') ? width/2 : width;
    
          this.css({width: width, height: height});
    
          if (data.pageObjs[0])
            data.pageObjs[0].css({width: pageWidth, height: height});
          
          for (page in data.pageWrap) {
            if (!has(page, data.pageWrap)) continue;
    
            prop = turnMethods._pageSize.call(this, page, true);
    
            data.pageObjs[page].css({width: prop.width, height: prop.height});
            data.pageWrap[page].css(prop);
            
            if (data.pages[page])
              data.pages[page].css({width: prop.width, height: prop.height});
          }
    
          this.turn('resize');
    
          return this;
    
        }
      },
    
      // Resizes each page
    
      resize: function() {
    
        var page, data = this.data();
    
        if (data.pages[0]) {
          data.pageWrap[0].css({left: -this.width()});
          data.pages[0].flip('resize', true);
        }
    
        for (page = 1; page <= data.totalPages; page++)
          if (data.pages[page])
            data.pages[page].flip('resize', true);
    
        turnMethods._updateShadow.call(this);
    
        if (data.opts.autoCenter)
          this.turn('center');
    
      },
    
      // Removes an animation from the cache
    
      _removeMv: function(page) {
    
        var i, data = this.data();
          
        for (i=0; i<data.pageMv.length; i++)
          if (data.pageMv[i]==page) {
            data.pageMv.splice(i, 1);
            return true;
          }
    
        return false;
    
      },
    
      // Adds an animation to the cache
      
      _addMv: function(page) {
    
        var data = this.data();
    
        turnMethods._removeMv.call(this, page);
        data.pageMv.push(page);
    
      },
    
      // Gets indexes for a view
    
      _view: function(page) {
      
        var data = this.data();
        
        page = page || data.page;
    
        if (data.display=='double')
          return (page%2) ? [page-1, page] : [page, page+1];
        else
          return [page];
    
      },
    
      // Gets a view
    
      view: function(page) {
    
        var data = this.data(),
          view = turnMethods._view.call(this, page);
    
        if (data.display=='double')
          return [(view[0]>0) ? view[0] : 0,
            (view[1]<=data.totalPages) ? view[1] : 0];
        else
          return [(view[0]>0 && view[0]<=data.totalPages) ? view[0] : 0];
    
      },
    
      // Stops animations
    
      stop: function(ignore, animate) {
    
        if (this.turn('animating')) {
      
          var i, opts, page,
            data = this.data();
    
          if (data.tpage) {
            data.page = data.tpage;
            delete data['tpage'];
          }
    
          for (i = 0; i<data.pageMv.length; i++) {
    
            if (!data.pageMv[i] || data.pageMv[i]===ignore)
              continue;
    
            page = data.pages[data.pageMv[i]];
            opts = page.data().f.opts;
    
            page.flip('hideFoldedPage', animate);
    
            if (!animate)
              flipMethods._moveFoldingPage.call(page, false);
    
            if (opts.force) {
              opts.next = (opts.page%2===0) ? opts.page-1 : opts.page+1;
              delete opts['force'];
            }
    
          }
        }
        
        this.turn('update');
    
        return this;
      },
    
      // Gets and sets the number of pages
    
      pages: function(pages) {
    
        var data = this.data();
    
        if (pages) {
    
          if (pages<data.totalPages) {
    
            for (var page = data.totalPages; page>pages; page--)
              this.turn('removePage', page);
    
          }
    
            data.totalPages = pages;
            turnMethods._fitPage.call(this, data.page);
    
          return this;
    
        } else
          return data.totalPages;
    
      },
    
      // Checks missing pages
    
      _missing : function(page) {
        
        var data = this.data();
    
        if (data.totalPages<1)
          return;
    
        var p,
            range = this.turn('range', page),
            missing = [];
    
        for (p = range[0]; p<=range[1]; p++) {
          if (!data.pageObjs[p])
            missing.push(p);
        }
    
        if (missing.length>0)
          this.trigger('missing', [missing]);
    
      },
    
      // Sets a page without effect
    
      _fitPage: function(page) {
    
        var data = this.data(),
          newView = this.turn('view', page);
    
        turnMethods._missing.call(this, page);
        
        if (!data.pageObjs[page])
          return;
    
        data.page = page;
      
        this.turn('stop');
    
        for (var i = 0; i<newView.length; i++) {
    
          if (newView[i] && data.pageZoom[newView[i]]!=data.zoom) {
      
            this.trigger('zoomed',[
              newView[i],
              newView,
              data.pageZoom[newView[i]],
              data.zoom]);
    
            data.pageZoom[newView[i]] = data.zoom;
    
          }
        }
    
        turnMethods._removeFromDOM.call(this);
        turnMethods._makeRange.call(this);
        turnMethods._updateShadow.call(this);
        this.trigger('turned', [page, newView]);
        this.turn('update');
    
        if (data.opts.autoCenter)
          this.turn('center');
    
      },
      
      // Turns the page
    
      _turnPage: function(page) {
    
        var current,
          next,
          data = this.data(),
          place = data.pagePlace[page],
          view = this.turn('view'),
          newView = this.turn('view', page);
    
    
        if (data.page!=page) {
    
          var currentPage = data.page;
    
          if (trigger('turning', this, [page, newView])=='prevented') {
    
            if (currentPage==data.page && $.inArray(place, data.pageMv)!=-1)
              data.pages[place].flip('hideFoldedPage', true);
            
            return;
    
          }
    
          if ($.inArray(1, newView)!=-1)
            this.trigger('first');
          if ($.inArray(data.totalPages, newView)!=-1)
            this.trigger('last');
    
        }
    
        if (data.display=='single') {
          current = view[0];
          next = newView[0];
        } else if (view[1] && page>view[1]) {
          current = view[1];
          next = newView[0];
        } else if (view[0] && page<view[0]) {
          current = view[0];
          next = newView[1];
        }
    
        var optsCorners = data.opts.turnCorners.split(','),
          flipData = data.pages[current].data().f,
          opts = flipData.opts,
          actualPoint = flipData.point;
    
        turnMethods._missing.call(this, page);
        
        if (!data.pageObjs[page])
          return;
    
        this.turn('stop');
    
        data.page = page;
    
        turnMethods._makeRange.call(this);
    
        data.tpage = next;
    
        if (opts.next!=next) {
          opts.next = next;
          opts.force = true;
        }
    
        this.turn('update');
    
        flipData.point = actualPoint;
        
        if (flipData.effect=='hard')
          if (data.direction=='ltr')
            data.pages[current].flip('turnPage',
              (page>current) ? 'r' : 'l');
          else
            data.pages[current].flip('turnPage',
              (page>current) ? 'l' : 'r');
        else {
          if (data.direction=='ltr')
            data.pages[current].flip('turnPage',
              optsCorners[(page>current) ? 1 : 0]);
          else
            data.pages[current].flip('turnPage',
              optsCorners[(page>current) ? 0 : 1]);
        }
    
      },
    
      // Gets and sets a page
    
      page: function(page) {
    
        var data = this.data();
    
        if (page===undefined) {
          
          return data.page;
    
        } else {
    
          if (!data.disabled && !data.destroying) {
    
            page = parseInt(page, 10);
    
            if (page>0 && page<=data.totalPages) {
    
              if (page!=data.page) {
                if (!data.done || $.inArray(page, this.turn('view'))!=-1)
                  turnMethods._fitPage.call(this, page);
                else
                  turnMethods._turnPage.call(this, page);
              }
          
              return this;
    
            } else {
            
              throw turnError('The page ' + page + ' does not exist');
    
            }
    
          }
    
        }
    
      },
    
      // Turns to the next view
    
      next: function() {
        return this.turn('page', Math.min(this.data().totalPages,
          turnMethods._view.call(this, this.data().page).pop() + 1));
      
      },
    
      // Turns to the previous view
    
      previous: function() {
    
        return this.turn('page', Math.max(1,
          turnMethods._view.call(this, this.data().page).shift() - 1));
    
      },
    
      // Shows a peeling corner
    
      peel: function(corner, animate) {
        
        var data = this.data(),
          view = this.turn('view');
    
        animate = (animate===undefined) ? true : animate===true;
    
        if (corner===false) {
          
          this.turn('stop', null, animate);
    
        } else {
        
          if (data.display=='single') {
    
            data.pages[data.page].flip('peel', corner, animate);
    
          } else {
    
            var page;
    
            if (data.direction=='ltr') {
              
              page = (corner.indexOf('l')!=-1) ? view[0] : view[1];
    
            } else {
              
              page = (corner.indexOf('l')!=-1) ? view[1] : view[0];
    
            }
            
            if (data.pages[page])
              data.pages[page].flip('peel', corner, animate);
    
          }
        }
    
        return this;
    
      },
    
      // Adds a motion to the internal list
      // This event is called in context of flip
    
      _addMotionPage: function() {
    
        var opts = $(this).data().f.opts,
          turn = opts.turn,
          dd = turn.data();
    
        turnMethods._addMv.call(turn, opts.page);
    
      },
    
      // This event is called in context of flip
    
      _eventStart: function(e, opts, corner) {
    
        var data = opts.turn.data(),
          actualZoom = data.pageZoom[opts.page];
    
        if (e.isDefaultPrevented()) {
          turnMethods._updateShadow.call(opts.turn);
          return;
        }
    
        if (actualZoom && actualZoom!=data.zoom) {
          
          opts.turn.trigger('zoomed',[
            opts.page,
            opts.turn.turn('view', opts.page),
            actualZoom,
            data.zoom]);
    
          data.pageZoom[opts.page] = data.zoom;
    
        }
    
        if (data.display=='single' && corner) {
    
          if ((corner.charAt(1)=='l' && data.direction=='ltr') ||
            (corner.charAt(1)=='r' && data.direction=='rtl'))
          {
            
            opts.next = (opts.next<opts.page) ? opts.next : opts.page-1;
            opts.force = true;
    
          } else {
            
            opts.next = (opts.next>opts.page) ? opts.next : opts.page+1;
    
          }
    
        }
    
        turnMethods._addMotionPage.call(e.target);
        turnMethods._updateShadow.call(opts.turn);
      },
    
      // This event is called in context of flip
    
      _eventEnd: function(e, opts, turned) {
      
        var that = $(e.target),
          data = that.data().f,
          turn = opts.turn,
          dd = turn.data();
    
        if (turned) {
    
          var tpage = dd.tpage || dd.page;
        
          if (tpage==opts.next || tpage==opts.page) {
            delete dd.tpage;
    
            turnMethods._fitPage.call(turn, tpage || opts.next, true);
          }
    
        } else {
          
          turnMethods._removeMv.call(turn, opts.page);
          turnMethods._updateShadow.call(turn);
          turn.turn('update');
    
        }
        
      },
      
      // This event is called in context of flip
    
      _eventPressed: function(e) {
    
        var page,
          data = $(e.target).data().f,
          turn = data.opts.turn,
          turnData = turn.data(),
          pages = turnData.pages;
        
        turnData.mouseAction = true;
    
        turn.turn('update');
    
        return data.time = new Date().getTime();
    
      },
    
      // This event is called in context of flip
    
      _eventReleased: function(e, point) {
    
        var outArea,
          page = $(e.target),
          data = page.data().f,
          turn = data.opts.turn,
          turnData = turn.data();
        
        if (turnData.display=='single') {
          outArea = (point.corner=='br' || point.corner=='tr') ?
            point.x<page.width()/2:
            point.x>page.width()/2;
        } else {
          outArea = point.x<0 || point.x>page.width();
        }
    
        if ((new Date()).getTime()-data.time<200 || outArea) {
    
          e.preventDefault();
          turnMethods._turnPage.call(turn, data.opts.next);
    
        }
    
        turnData.mouseAction = false;
    
      },
    
      // This event is called in context of flip
      
      _flip: function(e) {
    
        e.stopPropagation();
    
        var opts = $(e.target).data().f.opts;
    
        opts.turn.trigger('turn', [opts.next]);
    
        if (opts.turn.data().opts.autoCenter) {
          opts.turn.turn('center', opts.next);
        }
    
      },
    
     //
      _touchStart: function() {
        var data = this.data();
        for (var page in data.pages) {
          if (has(page, data.pages) &&
            flipMethods._eventStart.apply(data.pages[page], arguments)===false) {
              return false;
          }
        }
      },
      
      //
      _touchMove: function() {
        var data = this.data();
        for (var page in data.pages) {
          if (has(page, data.pages)) {
            flipMethods._eventMove.apply(data.pages[page], arguments);
          }
        }
      },
    
      //
      _touchEnd: function() {
        var data = this.data();
        for (var page in data.pages) {
          if (has(page, data.pages)) {
            flipMethods._eventEnd.apply(data.pages[page], arguments);
          }
        }
      },
    
      // Calculate the z-index value for pages during the animation
    
      calculateZ: function(mv) {
    
        var i, page, nextPage, placePage, dpage,
          that = this,
          data = this.data(),
          view = this.turn('view'),
          currentPage = view[0] || view[1],
          total = mv.length-1,
          r = {pageZ: {}, partZ: {}, pageV: {}},
    
          addView = function(page) {
            var view = that.turn('view', page);
            if (view[0]) r.pageV[view[0]] = true;
            if (view[1]) r.pageV[view[1]] = true;
          };
        
        for (i = 0; i<=total; i++) {
          page = mv[i];
          nextPage = data.pages[page].data().f.opts.next;
          placePage = data.pagePlace[page];
          addView(page);
          addView(nextPage);
          dpage = (data.pagePlace[nextPage]==nextPage) ? nextPage : page;
          r.pageZ[dpage] = data.totalPages - Math.abs(currentPage-dpage);
          r.partZ[placePage] = data.totalPages*2 -  total + i;
        }
    
        return r;
      },
    
      // Updates the z-index and display property of every page
    
      update: function() {
    
        var page,
          data = this.data();
    
        if (this.turn('animating') && data.pageMv[0]!==0) {
    
          // Update motion
    
          var p, apage, fixed,
            pos = this.turn('calculateZ', data.pageMv),
            corner = this.turn('corner'),
            actualView = this.turn('view'),
            newView = this.turn('view', data.tpage);
      
          for (page in data.pageWrap) {
    
            if (!has(page, data.pageWrap))
              continue;
    
            fixed = data.pageObjs[page].hasClass('fixed');
    
            data.pageWrap[page].css({
              display: (pos.pageV[page] || fixed) ? '' : 'none',
              zIndex:
                (data.pageObjs[page].hasClass('hard') ?
                  pos.partZ[page]
                  :
                  pos.pageZ[page]
                ) || (fixed ? -1 : 0)
            });
    
            if ((p = data.pages[page])) {
    
              p.flip('z', pos.partZ[page] || null);
    
              if (pos.pageV[page])
                p.flip('resize');
              
              if (data.tpage) { // Is it turning the page to `tpage`?
    
                p.flip('hover', false).
                  flip('disable',
                    $.inArray(parseInt(page, 10), data.pageMv)==-1 &&
                    page!=newView[0] &&
                    page!=newView[1]);
    
              } else {
    
                p.flip('hover', corner===false).
                  flip('disable', page!=actualView[0] && page!=actualView[1]);
    
              }
    
            }
    
          }
    
        } else {
    
          // Update static pages
    
          for (page in data.pageWrap) {
    
            if (!has(page, data.pageWrap))
              continue;
    
            var pageLocation = turnMethods._setPageLoc.call(this, page);
    
            if (data.pages[page]) {
              data.pages[page].
                flip('disable', data.disabled || pageLocation!=1).
                flip('hover', true).
                flip('z', null);
            }
          }
        }
    
        return this;
      },
    
      // Updates the position and size of the flipbook's shadow
    
      _updateShadow: function() {
        
        var view, view2, shadow,
          data = this.data(),
          width = this.width(),
          height = this.height(),
          pageWidth = (data.display=='single') ? width : width/2;
    
        view = this.turn('view');
    
        if (!data.shadow) {
          data.shadow = $('<div />', {
              'class': 'shadow',
              'css': divAtt(0, 0, 0).css
            }).
            appendTo(this);
        }
    
        for (var i = 0; i<data.pageMv.length; i++) {
          if (!view[0] || !view[1])
            break;
        
          view = this.turn('view', data.pages[data.pageMv[i]].data().f.opts.next);
          view2 = this.turn('view', data.pageMv[i]);
    
          view[0] = view[0] && view2[0];
          view[1] = view[1] && view2[1];
        }
    
        if (!view[0]) shadow = (data.direction=='ltr') ? 1 : 2;
        else if (!view[1]) shadow = (data.direction=='ltr') ? 2 : 1;
        else shadow = 3;
    
        switch (shadow) {
          case 1:
            data.shadow.css({
              width: pageWidth,
              height: height,
              top: 0,
              left: pageWidth
            });
            break;
          case 2:
            data.shadow.css({
              width: pageWidth,
              height: height,
              top: 0,
              left: 0
            });
            break;
          case 3:
            data.shadow.css({
              width: width,
              height: height,
              top: 0,
              left: 0
            });
            break;
        }
    
      },
    
      // Sets the z-index and display property of a page
      // It depends on the current view
    
      _setPageLoc: function(page) {
    
        var data = this.data(),
          view = this.turn('view'),
          loc = 0;
    
        
        if (page==view[0] || page==view[1])
          loc = 1;
        else if (
          (data.display=='single' && page==view[0]+1) ||
          (data.display=='double' && page==view[0]-2 || page==view[1]+2)
        )
          loc = 2;
    
        if (!this.turn('animating'))
          switch (loc) {
            case 1:
              data.pageWrap[page].css(
              {
                zIndex: data.totalPages,
                display: ''
              });
            break;
            case 2:
              data.pageWrap[page].css(
              {
                zIndex: data.totalPages-1,
                display: ''
              });
            break;
            case 0:
              data.pageWrap[page].css(
              {
                zIndex: 0,
                display: (data.pageObjs[page].hasClass('fixed')) ? '' : 'none'}
              );
            break;
          }
        
        return loc;
      },
    
      // Gets and sets the options
    
      options: function(options) {
        
        if (options===undefined) {
          
          return this.data().opts;
    
        } else {
    
          var data = this.data();
    
          // Set new values
    
          $.extend(data.opts, options);
          
          // Set pages
    
          if (options.pages)
            this.turn('pages', options.pages);
    
          // Set page
    
          if (options.page)
            this.turn('page', options.page);
    
          // Set display
    
          if (options.display)
            this.turn('display', options.display);
          
          // Set direction
    
          if (options.direction)
            this.turn('direction', options.direction);
    
          // Set size
    
          if (options.width && options.height)
            this.turn('size', options.width, options.height);
          
          // Add event listeners
    
          if (options.when)
            for (var eventName in options.when)
              if (has(eventName, options.when)) {
                this.unbind(eventName).
                  bind(eventName, options.when[eventName]);
              }
    
          return this;
        }
    
      },
    
      // Gets the current version
    
      version: function() {
    
        return version;
    
      }
    },
    
    // Methods and properties for the flip page effect
    
    flipMethods = {
    
      // Constructor
    
      init: function(opts) {
    
        this.data({f: {
          disabled: false,
          hover: false,
          effect: (this.hasClass('hard')) ? 'hard' : 'sheet'
        }});
      
        this.flip('options', opts);
    
        flipMethods._addPageWrapper.call(this);
    
        return this;
      },
    
      setData: function(d) {
        
        var data = this.data();
    
        data.f = $.extend(data.f, d);
    
        return this;
      },
    
      options: function(opts) {
        
        var data = this.data().f;
    
        if (opts) {
          flipMethods.setData.call(this,
            {opts: $.extend({}, data.opts || flipOptions, opts)});
          return this;
        } else
          return data.opts;
    
      },
    
      z: function(z) {
        
        var data = this.data().f;
    
        data.opts['z-index'] = z;
    
        if (data.fwrapper)
          data.fwrapper.css({
            zIndex: z || parseInt(data.parent.css('z-index'), 10) || 0
          });
    
        return this;
      },
    
      _cAllowed: function() {
        
        var data = this.data().f,
          page = data.opts.page,
          turnData = data.opts.turn.data(),
          odd = page%2;
        
        if (data.effect=='hard') {
        
          return (turnData.direction=='ltr') ?
            [(odd) ? 'r' : 'l'] :
            [(odd) ? 'l' : 'r'];
    
        } else {
    
          if (turnData.display=='single') {
    
            if (page==1)
              return (turnData.direction=='ltr') ?
                corners['forward'] : corners['backward'];
            else if (page==turnData.totalPages)
              return (turnData.direction=='ltr') ?
                corners['backward'] : corners['forward'];
            else
              return corners['all'];
    
          } else {
    
            return (turnData.direction=='ltr') ?
              corners[(odd) ? 'forward' : 'backward']
              :
              corners[(odd) ? 'backward' : 'forward'];
    
          }
    
        }
    
      },
    
      _cornerActivated: function(p) {
    
        var data = this.data().f,
          width = this.width(),
          height = this.height(),
          point = {x: p.x, y: p.y, corner: ''},
          csz = data.opts.cornerSize;
    
        if (point.x<=0 || point.y<=0 || point.x>=width || point.y>=height)
          return false;
    
        var allowedCorners = flipMethods._cAllowed.call(this);
    
        switch (data.effect) {
          case 'hard':
            
            if (point.x>width-csz)
              point.corner = 'r';
            else if (point.x<csz)
              point.corner = 'l';
            else
              return false;
                
            break;
    
          case 'sheet':
            
            if (point.y<csz)
              point.corner+= 't';
            else if (point.y>=height-csz)
              point.corner+= 'b';
            else
              return false;
        
            if (point.x<=csz)
              point.corner+= 'l';
            else if (point.x>=width-csz)
              point.corner+= 'r';
            else
              return false;
         
            break;
          }
    
        return (!point.corner || $.inArray(point.corner, allowedCorners)==-1) ?
          false : point;
    
      },
    
      _isIArea: function(e) {
    
        var pos = this.data().f.parent.offset();
    
        e = (isTouch && e.originalEvent) ? e.originalEvent.touches[0] : e;
    
        return flipMethods._cornerActivated.call(this,
          {
            x: e.pageX-pos.left,
            y: e.pageY-pos.top
          });
    
      },
    
      _c: function(corner, opts) {
    
        opts = opts || 0;
    
        switch (corner) {
          case 'tl':
            return point2D(opts, opts);
          case 'tr':
            return point2D(this.width()-opts, opts);
          case 'bl':
            return point2D(opts, this.height()-opts);
          case 'br':
            return point2D(this.width()-opts, this.height()-opts);
          case 'l':
            return point2D(opts, 0);
          case 'r':
            return point2D(this.width()-opts, 0);
        }
    
      },
    
      _c2: function(corner) {
    
        switch (corner) {
          case 'tl':
            return point2D(this.width()*2, 0);
          case 'tr':
            return point2D(-this.width(), 0);
          case 'bl':
            return point2D(this.width()*2, this.height());
          case 'br':
            return point2D(-this.width(), this.height());
          case 'l':
            return point2D(this.width()*2, 0);
          case 'r':
            return point2D(-this.width(), 0);
        }
    
      },
    
      _foldingPage: function() {
    
        var data = this.data().f;
    
        if (!data)
          return;
    
        var opts = data.opts;
    
        if (opts.turn) {
          data = opts.turn.data();
          if (data.display == 'single')
            return (opts.next>1 || opts.page>1) ? data.pageObjs[0] : null;
          else
            return data.pageObjs[opts.next];
        }
    
      },
    
      _backGradient: function() {
    
        var data = this.data().f,
          turnData = data.opts.turn.data(),
          gradient =  turnData.opts.gradients && (turnData.display=='single' ||
             (data.opts.page!=2 && data.opts.page!=turnData.totalPages-1));
    
        if (gradient && !data.bshadow)
          data.bshadow = $('<div/>', divAtt(0, 0, 1)).
            css({'position': '', width: this.width(), height: this.height()}).
            appendTo(data.parent);
    
        return gradient;
    
      },
    
      type: function () {
        
        return this.data().f.effect;
    
      },
    
      resize: function(full) {
        
        var data = this.data().f,
          turnData = data.opts.turn.data(),
          width = this.width(),
          height = this.height();
    
        switch (data.effect) {
          case 'hard':
            
          if (full) {
            data.wrapper.css({width: width, height: height});
            data.fpage.css({width: width, height: height});
            if (turnData.opts.gradients) {
              data.ashadow.css({width: width, height: height});
              data.bshadow.css({width: width, height: height});
            }
          }
    
          break;
          case 'sheet':
    
          if (full) {
            var size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));
    
            data.wrapper.css({width: size, height: size});
            data.fwrapper.css({width: size, height: size}).
              children(':first-child').
              css({width: width, height: height});
    
            data.fpage.css({width: width, height: height});
    
            if (turnData.opts.gradients)
              data.ashadow.css({width: width, height: height});
    
            if (flipMethods._backGradient.call(this))
              data.bshadow.css({width: width, height: height});
          }
    
          if (data.parent.is(':visible')) {
            var offset = findPos(data.parent[0]);
    
            data.fwrapper.css({top: offset.top,
              left: offset.left});
    
            //if (data.opts.turn) {
             offset = findPos(data.opts.turn[0]);
             data.fparent.css({top: -offset.top, left: -offset.left});
            //}
          }
    
          this.flip('z', data.opts['z-index']);
    
          break;
        }
    
      },
    
      // Prepares the page by adding a general wrapper and another objects
    
      _addPageWrapper: function() {
    
        var att,
          data = this.data().f,
          turnData = data.opts.turn.data(),
          parent = this.parent();
    
        data.parent = parent;
    
      if (!data.wrapper)
        switch (data.effect) {
          case 'hard':
            
            var cssProperties = {};
            cssProperties[vendor + 'transform-style'] = 'preserve-3d';
            cssProperties[vendor + 'backface-visibility'] = 'hidden';
    
            data.wrapper = $('<div/>', divAtt(0, 0, 2)).
              css(cssProperties).
              appendTo(parent).
              prepend(this);
    
            data.fpage = $('<div/>', divAtt(0, 0, 1)).
              css(cssProperties).
              appendTo(parent);
            
            if (turnData.opts.gradients) {
              data.ashadow = $('<div/>', divAtt(0, 0,  0)).
                hide().
                appendTo(parent);
    
              data.bshadow = $('<div/>', divAtt(0, 0,  0));
            }
    
          break;
          case 'sheet':
            
            var width = this.width(),
              height = this.height(),
              size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));
            
            data.fparent = data.opts.turn.data().fparent;
    
            if (!data.fparent) {
              var fparent = $('<div/>', {css: {'pointer-events': 'none'}}).hide();
                fparent.data().flips = 0;
                fparent.css(divAtt(0, 0, 'auto', 'visible').css).
                appendTo(data.opts.turn);
                
                data.opts.turn.data().fparent = fparent;
                data.fparent = fparent;
            }
    
            this.css({position: 'absolute', top: 0, left: 0, bottom: 'auto', right: 'auto'});
    
            data.wrapper = $('<div/>', divAtt(0, 0, this.css('z-index'))).
              appendTo(parent).
              prepend(this);
    
            data.fwrapper = $('<div/>', divAtt(parent.offset().top, parent.offset().left)).
              hide().
              appendTo(data.fparent);
    
            data.fpage = $('<div/>', divAtt(0, 0, 0, 'visible')).
              css({cursor: 'default'}).
              appendTo(data.fwrapper);
    
            if (turnData.opts.gradients)
              data.ashadow = $('<div/>', divAtt(0, 0,  1)).
              appendTo(data.fpage);
    
            flipMethods.setData.call(this, data);
    
          break;
        }
    
        // Set size
        flipMethods.resize.call(this, true);
    
      },
    
      // Takes a 2P point from the screen and applies the transformation
    
      _fold: function(point) {
    
        var data = this.data().f,
          turnData = data.opts.turn.data(),
          o = flipMethods._c.call(this, point.corner),
          width = this.width(),
          height = this.height();
    
        switch (data.effect) {
    
          case 'hard':
    
            if (point.corner=='l')
              point.x = Math.min(Math.max(point.x, 0), width*2);
            else
              point.x = Math.max(Math.min(point.x, width), -width);
    
            var leftPos,
              shadow,
              gradientX,
              fpageOrigin,
              parentOrigin,
              totalPages = turnData.totalPages,
              zIndex = data.opts['z-index'] || totalPages,
              parentCss = {'overflow': 'visible'},
              relX = (o.x) ? (o.x - point.x)/width : point.x/width,
              angle = relX * 90,
              half = angle<90;
    
            switch (point.corner) {
              case 'l':
    
                fpageOrigin =  '0% 50%';
                parentOrigin =  '100% 50%';
    
                if (half) {
                  leftPos = 0;
                  shadow = data.opts.next-1>0;
                  gradientX = 1;
                } else {
                  leftPos = '100%';
                  shadow = data.opts.page+1<totalPages;
                  gradientX = 0;
                }
    
              break;
              case 'r':
    
                fpageOrigin =  '100% 50%';
                parentOrigin =  '0% 50%';
                angle = -angle;
                width = -width;
    
                if (half) {
                  leftPos = 0;
                  shadow = data.opts.next+1<totalPages;
                  gradientX = 0;
                } else {
                  leftPos = '-100%';
                  shadow = data.opts.page!=1;
                  gradientX = 1;
                }
    
              break;
            }
    
            parentCss[vendor+'perspective-origin'] = parentOrigin;
    
            data.wrapper.transform('rotateY('+angle+'deg)' +
              'translate3d(0px, 0px, '+(this.attr('depth')||0)+'px)', parentOrigin);
    
            data.fpage.transform('translateX('+width+'px) rotateY('+(180+angle)+'deg)', fpageOrigin);
    
            data.parent.css(parentCss);
    
            if (half) {
              relX = -relX+1;
              data.wrapper.css({zIndex: zIndex+1});
              data.fpage.css({zIndex: zIndex});
            } else {
              relX = relX-1;
              data.wrapper.css({zIndex: zIndex});
              data.fpage.css({zIndex: zIndex+1});
            }
    
            if (turnData.opts.gradients) {
              if (shadow)
                data.ashadow.css({
                  display: '',
                  left: leftPos,
                  backgroundColor: 'rgba(0,0,0,'+(0.5*relX)+')'
                }).
                transform('rotateY(0deg)');
              else
                data.ashadow.hide();
    
              data.bshadow.css({opacity:-relX + 1});
    
              if (half) {
                if (data.bshadow.parent()[0]!=data.wrapper[0]) {
                  data.bshadow.appendTo(data.wrapper);
                }
              } else {
                if (data.bshadow.parent()[0]!=data.fpage[0]) {
                  data.bshadow.appendTo(data.fpage);
                }
              }
              /*data.bshadow.css({
                backgroundColor: 'rgba(0,0,0,'+(0.1)+')'
              })*/
              gradient(data.bshadow, point2D(gradientX * 100, 0), point2D((-gradientX + 1)*100, 0),
                [[0, 'rgba(0,0,0,0.3)'],[1, 'rgba(0,0,0,0)']],2);
              
            }
    
            break;
          case 'sheet':
    
            var that = this,
              a = 0,
              alpha = 0,
              beta,
              px,
              gradientEndPointA,
              gradientEndPointB,
              gradientStartVal,
              gradientSize,
              gradientOpacity,
              shadowVal,
              mv = point2D(0, 0),
              df = point2D(0, 0),
              tr = point2D(0, 0),
              folding = flipMethods._foldingPage.call(this),
              tan = Math.tan(alpha),
              ac = turnData.opts.acceleration,
              h = data.wrapper.height(),
              top = point.corner.substr(0, 1) == 't',
              left = point.corner.substr(1, 1) == 'l',
    
          compute = function() {
    
            var rel = point2D(0, 0);
            var middle = point2D(0, 0);
    
            rel.x = (o.x) ? o.x - point.x : point.x;
    
            if (!hasRot) {
              rel.y = 0;
            } else {
              rel.y = (o.y) ? o.y - point.y : point.y;
            }
    
            middle.x = (left)? width - rel.x/2 : point.x + rel.x/2;
            middle.y = rel.y/2;
            
            var alpha =  A90-Math.atan2(rel.y, rel.x),
              gamma = alpha - Math.atan2(middle.y, middle.x),
              distance =  Math.max(0, Math.sin(gamma) * Math.sqrt(Math.pow(middle.x, 2) + Math.pow(middle.y, 2)));
              
              a = deg(alpha);
    
              tr = point2D(distance * Math.sin(alpha), distance * Math.cos(alpha));
    
              if (alpha > A90) {
                tr.x = tr.x + Math.abs(tr.y * rel.y/rel.x);
                tr.y = 0;
                if (Math.round(tr.x*Math.tan(PI-alpha)) < height) {
                  point.y = Math.sqrt(Math.pow(height, 2)+2 * middle.x * rel.x);
                  if (top) point.y =  height - point.y;
                  return compute();
                }
              }
          
              if (alpha>A90) {
                var beta = PI-alpha, dd = h - height/Math.sin(beta);
                mv = point2D(Math.round(dd*Math.cos(beta)), Math.round(dd*Math.sin(beta)));
                if (left) mv.x = - mv.x;
                if (top) mv.y = - mv.y;
              }
    
              px = Math.round(tr.y/Math.tan(alpha) + tr.x);
          
              var side = width - px,
                sideX = side*Math.cos(alpha*2),
                sideY = side*Math.sin(alpha*2);
                df = point2D(
                  Math.round((left ? side -sideX : px+sideX)),
                  Math.round((top) ? sideY : height - sideY));
              
            // Gradients
              if (turnData.opts.gradients) {
    
                gradientSize = side*Math.sin(alpha);
    
                var endingPoint = flipMethods._c2.call(that, point.corner),
                 far = Math.sqrt(Math.pow(endingPoint.x-point.x, 2)+Math.pow(endingPoint.y-point.y, 2))/width;
    
                shadowVal = Math.sin(A90*((far>1) ? 2 - far : far));
    
                gradientOpacity = Math.min(far, 1);
    
               
                  gradientStartVal = gradientSize>100 ? (gradientSize-100)/gradientSize : 0;
    
                  gradientEndPointA = point2D(
                    gradientSize*Math.sin(alpha)/width*100,
                    gradientSize*Math.cos(alpha)/height*100);
               
    
                  if (flipMethods._backGradient.call(that)) {
    
                    gradientEndPointB = point2D(
                      gradientSize*1.2*Math.sin(alpha)/width*100,
                      gradientSize*1.2*Math.cos(alpha)/height*100);
    
                    if (!left) gradientEndPointB.x = 100-gradientEndPointB.x;
                    if (!top) gradientEndPointB.y = 100-gradientEndPointB.y;
    
                  }
    
              }
    
              tr.x = Math.round(tr.x);
              tr.y = Math.round(tr.y);
    
            return true;
          },
    
          transform = function(tr, c, x, a) {
          
            var f = ['0', 'auto'], mvW = (width-h)*x[0]/100, mvH = (height-h)*x[1]/100,
              cssA = {left: f[c[0]], top: f[c[1]], right: f[c[2]], bottom: f[c[3]]},
              cssB = {},
              aliasingFk = (a!=90 && a!=-90) ? (left ? -1 : 1) : 0,
              origin = x[0] + '% ' + x[1] + '%';
    
            that.css(cssA).
              transform(rotate(a) + translate(tr.x + aliasingFk, tr.y, ac), origin);
    
            data.fpage.css(cssA).transform(
              rotate(a) +
              translate(tr.x + df.x - mv.x - width*x[0]/100, tr.y + df.y - mv.y - height*x[1]/100, ac) +
              rotate((180/a - 2)*a),
              origin);
    
            data.wrapper.transform(translate(-tr.x + mvW-aliasingFk, -tr.y + mvH, ac) + rotate(-a), origin);
    
            data.fwrapper.transform(translate(-tr.x + mv.x + mvW, -tr.y + mv.y + mvH, ac) + rotate(-a), origin);
          
            if (turnData.opts.gradients) {
    
              if (x[0])
                gradientEndPointA.x = 100-gradientEndPointA.x;
    
              if (x[1])
                gradientEndPointA.y = (100-gradientEndPointA.y);
    
              cssB['box-shadow'] = '0 0 20px rgba(0,0,0,'+(0.5*shadowVal)+')';
              folding.css(cssB);
    
              gradient(data.ashadow,
                  point2D(left?100:0, top?0:100),
                  point2D(gradientEndPointA.x, gradientEndPointA.y),
                  [[gradientStartVal, 'rgba(0,0,0,0)'],
                  [((1-gradientStartVal)*0.8)+gradientStartVal, 'rgba(0,0,0,'+(0.2*gradientOpacity)+')'],
                  [1, 'rgba(255,255,255,'+(0.2*gradientOpacity)+')']],
                  3,
                  alpha);
    
              if (flipMethods._backGradient.call(that))
                gradient(data.bshadow,
                    point2D(left?0:100, top?0:100),
                    point2D(gradientEndPointB.x, gradientEndPointB.y),
                    [[0.6, 'rgba(0,0,0,0)'],
                    [0.8, 'rgba(0,0,0,'+(0.3*gradientOpacity)+')'],
                    [1, 'rgba(0,0,0,0)']
                    ],
                    3);
            }
    
          };
    
          switch (point.corner) {
            case 'l' :
    
    
            break;
            case 'r' :
    
    
            break;
            case 'tl' :
              point.x = Math.max(point.x, 1);
              compute();
              transform(tr, [1,0,0,1], [100, 0], a);
            break;
            case 'tr' :
              point.x = Math.min(point.x, width-1);
              compute();
              transform(point2D(-tr.x, tr.y), [0,0,0,1], [0, 0], -a);
            break;
            case 'bl' :
              point.x = Math.max(point.x, 1);
              compute();
              transform(point2D(tr.x, -tr.y), [1,1,0,0], [100, 100], -a);
            break;
            case 'br' :
              point.x = Math.min(point.x, width-1);
              compute();
              transform(point2D(-tr.x, -tr.y), [0,1,1,0], [0, 100], a);
            break;
          }
    
        break;
      }
    
        data.point = point;
      
      },
    
      _moveFoldingPage: function(move) {
    
        var data = this.data().f;
    
        if (!data)
          return;
    
        var turn = data.opts.turn,
          turnData = turn.data(),
          place = turnData.pagePlace;
          
        if (move) {
    
          var nextPage = data.opts.next;
      
          if (place[nextPage]!=data.opts.page) {
    
            if (data.folding)
              flipMethods._moveFoldingPage.call(this, false);
    
            var folding = flipMethods._foldingPage.call(this);
            
            folding.appendTo(data.fpage);
            place[nextPage] = data.opts.page;
            data.folding = nextPage;
          }
    
          turn.turn('update');
    
        } else {
    
          if (data.folding) {
    
            if (turnData.pages[data.folding]) {
             
              // If we have flip available
    
              var flipData = turnData.pages[data.folding].data().f;
              
              turnData.pageObjs[data.folding].
                appendTo(flipData.wrapper);
    
            } else if (turnData.pageWrap[data.folding]) {
              
              // If we have the pageWrapper
    
              turnData.pageObjs[data.folding].
                appendTo(turnData.pageWrap[data.folding]);
    
            }
    
            if (data.folding in place) {
              place[data.folding] = data.folding;
            }
    
            delete data.folding;
    
          }
        }
      },
    
      _showFoldedPage: function(c, animate) {
    
        var folding = flipMethods._foldingPage.call(this),
          dd = this.data(),
          data = dd.f,
          visible = data.visible;
    
        if (folding) {
    
          if (!visible || !data.point || data.point.corner!=c.corner) {
    
            var corner = (
              data.status=='hover' ||
              data.status=='peel' ||
              data.opts.turn.data().mouseAction) ?
            c.corner : null;
    
            visible = false;
    
            if (trigger('start', this, [data.opts, corner])=='prevented')
              return false;
    
          }
    
          if (animate) {
            
            var that = this,
              point = (data.point && data.point.corner==c.corner) ?
              data.point : flipMethods._c.call(this, c.corner, 1);
          
            this.animatef({
              from: [point.x, point.y],
              to: [c.x, c.y],
              duration: 500,
              frame: function(v) {
                c.x = Math.round(v[0]);
                c.y = Math.round(v[1]);
                flipMethods._fold.call(that, c);
              }
            });
    
          } else  {
    
            flipMethods._fold.call(this, c);
    
            if (dd.effect && !dd.effect.turning)
              this.animatef(false);
    
          }
    
          if (!visible) {
    
            switch(data.effect) {
              case 'hard':
    
                data.visible = true;
                flipMethods._moveFoldingPage.call(this, true);
                data.fpage.show();
                if (data.opts.shadows)
                  data.bshadow.show();
    
              break;
              case 'sheet':
    
                data.visible = true;
                data.fparent.show().data().flips++;
                flipMethods._moveFoldingPage.call(this, true);
                data.fwrapper.show();
                if (data.bshadow)
                  data.bshadow.show();
    
              break;
            }
    
          }
    
          return true;
    
        }
    
        return false;
      },
    
      hide: function() {
    
        var data = this.data().f,
          turnData = data.opts.turn.data(),
          folding = flipMethods._foldingPage.call(this);
    
        switch (data.effect) {
          case 'hard':
            
            if (turnData.opts.gradients) {
              data.bshadowLoc = 0;
              data.bshadow.remove();
              data.ashadow.hide();
            }
    
            data.wrapper.transform('');
            data.fpage.hide();
    
          break;
          case 'sheet':
    
            if ((--data.fparent.data().flips)===0)
              data.fparent.hide();
    
            this.css({left: 0, top: 0, right: 'auto', bottom: 'auto'}).
              transform('');
    
            data.wrapper.transform('');
    
            data.fwrapper.hide();
    
            if (data.bshadow)
              data.bshadow.hide();
    
            folding.transform('');
    
          break;
        }
    
          data.visible = false;
    
        return this;
      },
    
      hideFoldedPage: function(animate) {
    
        var data = this.data().f;
    
        if (!data.point) return;
    
        var that = this,
          p1 = data.point,
          hide = function() {
            data.point = null;
            data.status = '';
            that.flip('hide');
            that.trigger('end', [data.opts, false]);
          };
    
        if (animate) {
    
          var p4 = flipMethods._c.call(this, p1.corner),
            top = (p1.corner.substr(0,1)=='t'),
            delta = (top) ? Math.min(0, p1.y-p4.y)/2 : Math.max(0, p1.y-p4.y)/2,
            p2 = point2D(p1.x, p1.y+delta),
            p3 = point2D(p4.x, p4.y-delta);
        
          this.animatef({
            from: 0,
            to: 1,
            frame: function(v) {
              var np = bezier(p1, p2, p3, p4, v);
              p1.x = np.x;
              p1.y = np.y;
              flipMethods._fold.call(that, p1);
            },
            complete: hide,
            duration: 800,
            hiding: true
          });
    
        } else {
    
          this.animatef(false);
          hide();
    
        }
      },
    
      turnPage: function(corner) {
    
        var that = this,
          data = this.data().f,
          turnData = data.opts.turn.data();
    
        corner = {corner: (data.corner) ?
          data.corner.corner :
          corner || flipMethods._cAllowed.call(this)[0]};
    
        var p1 = data.point ||
          flipMethods._c.call(this,
            corner.corner,
            (data.opts.turn) ? turnData.opts.elevation : 0),
          p4 = flipMethods._c2.call(this, corner.corner);
    
          this.trigger('flip').
            animatef({
              from: 0,
              to: 1,
              frame: function(v) {
    
                var np = bezier(p1, p1, p4, p4, v);
                corner.x = np.x;
                corner.y = np.y;
                flipMethods._showFoldedPage.call(that, corner);
    
              },
              complete: function() {
                
                that.trigger('end', [data.opts, true]);
    
              },
              duration: turnData.opts.duration,
              turning: true
            });
    
          data.corner = null;
      },
    
      moving: function() {
    
        return 'effect' in this.data();
      
      },
    
      isTurning: function() {
    
        return this.flip('moving') && this.data().effect.turning;
      
      },
    
      corner: function() {
        
        return this.data().f.corner;
          
      },
    
      _eventStart: function(e) {
    
        var data = this.data().f,
          turn = data.opts.turn;
    
        if (!data.corner && !data.disabled && !this.flip('isTurning') &&
          data.opts.page==turn.data().pagePlace[data.opts.page])
        {
    
          data.corner = flipMethods._isIArea.call(this, e);
    
          if (data.corner && flipMethods._foldingPage.call(this)) {
    
            this.trigger('pressed', [data.point]);
            flipMethods._showFoldedPage.call(this, data.corner);
    
            return false;
    
          } else
            data.corner = null;
    
        }
    
      },
    
      _eventMove: function(e) {
    
        var data = this.data().f;
    
        if (!data.disabled) {
    
          e = (isTouch) ? e.originalEvent.touches : [e];
    
          if (data.corner) {
    
            var pos = data.parent.offset();
            data.corner.x = e[0].pageX-pos.left;
            data.corner.y = e[0].pageY-pos.top;
            flipMethods._showFoldedPage.call(this, data.corner);
    
          } else if (data.hover && !this.data().effect && this.is(':visible')) {
    
            var point = flipMethods._isIArea.call(this, e[0]);
    
            if (point) {
    
              if ((data.effect=='sheet' && point.corner.length==2)  || data.effect=='hard') {
                data.status = 'hover';
                var origin = flipMethods._c.call(this, point.corner, data.opts.cornerSize/2);
                point.x = origin.x;
                point.y = origin.y;
                flipMethods._showFoldedPage.call(this, point, true);
              }
            
            } else {
              
              if (data.status=='hover') {
                data.status = '';
                flipMethods.hideFoldedPage.call(this, true);
              }
    
            }
    
          }
    
        }
    
      },
    
      _eventEnd: function() {
    
        var data = this.data().f,
          corner = data.corner;
    
        if (!data.disabled && corner) {
          if (trigger('released', this, [data.point || corner])!='prevented') {
            flipMethods.hideFoldedPage.call(this, true);
          }
        }
    
        data.corner = null;
    
      },
    
      disable: function(disable) {
    
        flipMethods.setData.call(this, {'disabled': disable});
        return this;
    
      },
    
      hover: function(hover) {
        
        flipMethods.setData.call(this, {'hover': hover});
        return this;
    
      },
    
      peel: function (corner, animate) {
    
        var data = this.data().f;
    
        if (corner) {
    
          if ($.inArray(corner, corners.all)==-1)
            throw turnError('Corner '+corner+' is not permitted');
    
          if ($.inArray(corner, flipMethods._cAllowed.call(this))!=-1) {
    
            var point = flipMethods._c.call(this, corner, data.opts.cornerSize/2);
            
            data.status = 'peel';
    
            flipMethods._showFoldedPage.call(this,
            {
              corner: corner,
              x: point.x,
              y: point.y
            }, animate);
    
          }
    
    
        } else {
    
          data.status = '';
    
          flipMethods.hideFoldedPage.call(this, animate);
          
        }
    
        return this;
      }
    };
    
    
    // Processes classes
    
    function dec(that, methods, args) {
    
      if (!args[0] || typeof(args[0])=='object')
        return methods.init.apply(that, args);
    
      else if (methods[args[0]])
        return methods[args[0]].apply(that, Array.prototype.slice.call(args, 1));
    
      else
        throw turnError(args[0] + ' is not a method or property');
    
    }
    
    
    // Attributes for a layer
    
    function divAtt(top, left, zIndex, overf) {
        
      return {'css': {
        position: 'absolute',
        top: top,
        left: left,
        'overflow': overf || 'hidden',
        zIndex: zIndex || 'auto'
      }
    };
          
    }
    
    // Gets a 2D point from a bezier curve of four points
    
    function bezier(p1, p2, p3, p4, t) {
    
      var a = 1 - t,
        b = a * a * a,
        c = t * t * t;
        
      return point2D(Math.round(b*p1.x + 3*t*a*a*p2.x + 3*t*t*a*p3.x + c*p4.x),
        Math.round(b*p1.y + 3*t*a*a*p2.y + 3*t*t*a*p3.y + c*p4.y));
    
    }
      
    // Converts an angle from degrees to radians
    
    function rad(degrees) {
      
      return degrees/180*PI;
    
    }
    
    // Converts an angle from radians to degrees
    
    function deg(radians) {
      
      return radians/PI*180;
    
    }
    
    // Gets a 2D point
    
    function point2D(x, y) {
      
      return {x: x, y: y};
    
    }
    
    // Webkit 534.3 on Android wrongly repaints elements that use overflow:hidden + rotation
    
    function rotationAvailable() {
      var parts;
    
      if ((parts = /AppleWebkit\/([0-9\.]+)/i.exec(navigator.userAgent))) {
        var webkitVersion = parseFloat(parts[1]);
        return (webkitVersion>534.3);
      } else {
        return true;
      }
    }
    
    // Returns the traslate value
    
    function translate(x, y, use3d) {
      
      return (has3d && use3d) ? ' translate3d(' + x + 'px,' + y + 'px, 0px) '
      : ' translate(' + x + 'px, ' + y + 'px) ';
    
    }
    
    // Returns the rotation value
    
    function rotate(degrees) {
      
      return ' rotate(' + degrees + 'deg) ';
    
    }
    
    // Checks if a property belongs to an object
    
    function has(property, object) {
      
      return Object.prototype.hasOwnProperty.call(object, property);
    
    }
    
    // Gets the CSS3 vendor prefix
    
    function getPrefix() {
    
      var vendorPrefixes = ['Moz','Webkit','Khtml','O','ms'],
      len = vendorPrefixes.length,
      vendor = '';
    
      while (len--)
        if ((vendorPrefixes[len] + 'Transform') in document.body.style)
          vendor='-'+vendorPrefixes[len].toLowerCase()+'-';
    
      return vendor;
    
    }
    
    // Detects the transitionEnd Event
    
    function getTransitionEnd() {
    
      var t,
        el = document.createElement('fakeelement'),
        transitions = {
          'transition':'transitionend',
          'OTransition':'oTransitionEnd',
          'MSTransition':'transitionend',
          'MozTransition':'transitionend',
          'WebkitTransition':'webkitTransitionEnd'
        };
    
      for (t in transitions) {
        if (el.style[t] !== undefined) {
          return transitions[t];
        }
      }
    }
    
    // Gradients
    
    function gradient(obj, p0, p1, colors, numColors) {
    
      var j, cols = [];
    
      if (vendor=='-webkit-') {
    
        for (j = 0; j<numColors; j++)
          cols.push('color-stop('+colors[j][0]+', '+colors[j][1]+')');
        
        obj.css({'background-image':
            '-webkit-gradient(linear, '+
            p0.x+'% '+
            p0.y+'%,'+
            p1.x+'% '+
            p1.y+'%, '+
            cols.join(',') + ' )'});
      } else {
        
        p0 = {x:p0.x/100 * obj.width(), y:p0.y/100 * obj.height()};
        p1 = {x:p1.x/100 * obj.width(), y:p1.y/100 * obj.height()};
    
        var dx = p1.x-p0.x,
          dy = p1.y-p0.y,
          angle = Math.atan2(dy, dx),
          angle2 = angle - Math.PI/2,
          diagonal = Math.abs(obj.width()*Math.sin(angle2))+Math.abs(obj.height()*Math.cos(angle2)),
          gradientDiagonal = Math.sqrt(dy*dy + dx*dx),
          corner = point2D((p1.x<p0.x) ? obj.width() : 0, (p1.y<p0.y) ? obj.height() : 0),
          slope = Math.tan(angle),
          inverse = -1/slope,
          x = (inverse*corner.x - corner.y - slope*p0.x + p0.y)/(inverse-slope),
          c = {x: x, y: inverse*x - inverse*corner.x + corner.y},
          segA = (Math.sqrt( Math.pow(c.x-p0.x,2) + Math.pow(c.y-p0.y,2)));
    
          for (j = 0; j<numColors; j++)
            cols.push(' '+colors[j][1]+' '+((segA + gradientDiagonal*colors[j][0])*100/diagonal)+'%');
    
          obj.css({'background-image': vendor+'linear-gradient(' + (-angle) + 'rad,' + cols.join(',') + ')'});
      }
    }
    
    
    // Triggers an event
    
    function trigger(eventName, context, args) {
    
      var event = $.Event(eventName);
      context.trigger(event, args);
      if (event.isDefaultPrevented())
        return 'prevented';
      else if (event.isPropagationStopped())
        return 'stopped';
      else
        return '';
    }
    
    // JS Errors
    
    function turnError(message) {
    
      function TurnJsError(message) {
        this.name = "TurnJsError";
        this.message = message;
      }
    
      TurnJsError.prototype = new Error();
      TurnJsError.prototype.constructor = TurnJsError;
      return new TurnJsError(message);
    
    }
    
    // Find the offset of an element ignoring its transformation
    
    function findPos(obj) {
    
      var offset = {top: 0, left: 0};
    
      do{
        offset.left += obj.offsetLeft;
        offset.top += obj.offsetTop;
      } while ((obj = obj.offsetParent));
    
      return offset;
    
    }
    
    // Checks if there's hard page compatibility
    // IE9 is the only browser that does not support hard pages
    
    function hasHardPage() {
      return (navigator.userAgent.indexOf('MSIE 9.0')==-1);
    }
    
    // Request an animation
    
    window.requestAnim = (function() {
      return window.requestAnimationFrame ||
        window.webkitRequestAnimationFrame ||
        window.mozRequestAnimationFrame ||
        window.oRequestAnimationFrame ||
        window.msRequestAnimationFrame ||
        function(callback) {
          window.setTimeout(callback, 1000 / 60);
        };
    
    })();
    
    // Extend $.fn
    
    $.extend($.fn, {
    
      flip: function() {
        return dec($(this[0]), flipMethods, arguments);
      },
    
      turn: function() {
        return dec($(this[0]), turnMethods, arguments);
      },
    
      transform: function(transform, origin) {
    
        var properties = {};
        
        if (origin)
          properties[vendor+'transform-origin'] = origin;
        
        properties[vendor+'transform'] = transform;
      
        return this.css(properties);
    
      },
    
      animatef: function(point) {
    
        var data = this.data();
    
        if (data.effect)
          data.effect.stop();
    
        if (point) {
    
          if (!point.to.length) point.to = [point.to];
          if (!point.from.length) point.from = [point.from];
    
          var diff = [],
            len = point.to.length,
            animating = true,
            that = this,
            time = (new Date()).getTime(),
            frame = function() {
    
              if (!data.effect || !animating)
                return;
    
              var v = [],
                timeDiff = Math.min(point.duration, (new Date()).getTime() - time);
    
              for (var i = 0; i < len; i++)
                v.push(data.effect.easing(1, timeDiff, point.from[i], diff[i], point.duration));
    
              point.frame((len==1) ? v[0] : v);
    
              if (timeDiff==point.duration) {
                delete data['effect'];
                that.data(data);
                if (point.complete)
                  point.complete();
              } else {
                window.requestAnim(frame);
              }
            };
    
          for (var i = 0; i < len; i++)
            diff.push(point.to[i] - point.from[i]);
    
          data.effect = $.extend({
            stop: function() {
              animating = false;
            },
            easing: function (x, t, b, c, data) {
              return c * Math.sqrt(1 - (t=t/data-1)*t) + b;
            }
          }, point);
    
          this.data(data);
    
          frame();
    
        } else {
          
          delete data['effect'];
    
        }
      }
    });
    
    // Export some globals
    
    $.isTouch = isTouch;
    $.mouseEvents = mouseEvents;
    $.cssPrefix = getPrefix;
    $.cssTransitionEnd = getTransitionEnd;
    $.findPos = findPos;
    
    
    })(jQuery);
    